home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / 3DTOSHI2.ZIP / mpg3d / source / lg3drasg.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-21  |  59.1 KB  |  1,962 lines
  1.  
  2. // lg3drasg.cpp
  3. //
  4. // Copyright (c) 1996 by Toshiaki Tsuji, all rights reserved.
  5.  
  6. #include "stdgfx.h"
  7. #include "lg3dras.h"
  8.  
  9. LONG  _LeftX;
  10. LONG  _LeftY;
  11. LONG  _LeftU;
  12. LONG  _LeftV;
  13. LONG  _LeftI;
  14. LONG  _LeftZ;
  15. LONG  _LeftH;
  16.   
  17. LONG  _RightX;
  18. LONG  _RightY;
  19. LONG  _RightU;
  20. LONG  _RightV;
  21. LONG  _RightI;
  22. LONG  _RightZ;
  23. LONG  _RightH;
  24.   
  25. LONG  _LeftDx;
  26. LONG  _LeftDy;
  27. LONG  _LeftDu;
  28. LONG  _LeftDv;
  29. LONG  _LeftDI;
  30. LONG  _LeftDz;
  31. LONG  _LeftDh;
  32.   
  33. LONG  _RightDx;
  34. LONG  _RightDy;
  35. LONG  _RightDu;
  36. LONG  _RightDv;
  37. LONG  _RightDI;
  38. LONG  _RightDz;
  39. LONG  _RightDh;
  40.     
  41. BYTE*  _DestBuffer;
  42. BYTE*  _TextureBuffer;
  43. LONG   _AddDest;
  44. BYTE*  _ShadeBuffer;
  45. BYTE*  _BlendBuffer;
  46. BYTE*  _HazeBuffer;
  47. float* _DivTable;
  48.  
  49. LONG  Color;
  50. LONG  LoopCount;
  51. LONG  VMinX;
  52. LONG  VMaxX;
  53. LONG  VMinY;
  54. LONG  VMaxY;
  55. LONG  TempLen;
  56. LONG  TempVal;
  57.   
  58. // Inner Loop Delta
  59. LONG  InDeltaDI;
  60. LONG  InDeltaDu;
  61. LONG  InDeltaDv;
  62. LONG  InDeltaDh;
  63.  
  64. SHORT InLoopCount;
  65.  
  66. float DummyFloat;
  67.  
  68. // VOID _SetViewPortData ( LONG MinX, LONG MinY, LONG MaxX, LONG MaxY )
  69. //
  70. // EAX = MinX, EDX = MinY, EBX = MaxX, ECX = MaxY
  71.  
  72. VOID _SetViewPortData ( LONG MinX, LONG MinY, 
  73.                         LONG MaxX, LONG MaxY )
  74. {
  75.   VMinX = MinX;
  76.   VMinY = MinY;
  77.   VMaxX = MaxX;
  78.   VMaxY = MaxY;
  79. } // End of _SetViewPortData
  80.  
  81.  
  82. // VOID _DrawSolidNoHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  83. //
  84. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  85.  
  86. VOID _DrawSolidNoHorz ( LONG nColor, LONG nLoopCount, 
  87.                         LONG SkipRow, LONG SideClipped )
  88. {
  89.   if (SkipRow!=0)
  90.     {
  91.       _LeftX += _LeftDx*SkipRow;
  92.       _RightX += _RightDx*SkipRow;
  93.       _DestBuffer += _AddDest*SkipRow;
  94.     } // End if
  95.  
  96.   LONG i,j,DrawLen;
  97.   LONG DrawLeftX,DrawRightX;
  98.   BYTE *DrawBuffer;
  99.   nLoopCount -= SkipRow;
  100.  
  101.   if (!SideClipped)
  102.     {
  103.       for (i=0;i<nLoopCount;i++)
  104.         {
  105.           DrawLeftX = (_LeftX>>16);
  106.           DrawRightX = (_RightX>>16);
  107.           DrawBuffer = _DestBuffer + DrawLeftX;
  108.           DrawLen = DrawRightX - DrawLeftX + 1;
  109.           for (j=0;j<DrawLen;j++)
  110.             {
  111.               *DrawBuffer = (BYTE)nColor;
  112.               DrawBuffer++;
  113.             } // End for
  114.           _DestBuffer += _AddDest;
  115.           _LeftX += _LeftDx;
  116.           _RightX += _RightDx;
  117.         } // End for
  118.     } // End if
  119.   else
  120.     {
  121.       for (i=0;i<nLoopCount;i++)
  122.         {
  123.           DrawLeftX = (_LeftX>>16);
  124.           DrawRightX = (_RightX>>16);
  125.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  126.             {
  127.               if (DrawLeftX<VMinX)
  128.                 {
  129.                   DrawLeftX = VMinX;
  130.                 } // End if
  131.               if (DrawRightX>VMaxX)
  132.                 {
  133.                   DrawRightX = VMaxX;
  134.                 } // End if
  135.  
  136.               DrawBuffer = _DestBuffer + DrawLeftX;
  137.               DrawLen = DrawRightX - DrawLeftX + 1;
  138.               for (j=0;j<DrawLen;j++)
  139.                 {
  140.                   *DrawBuffer = (BYTE)nColor;
  141.                   DrawBuffer++;
  142.                 } // End for
  143.             } // End if
  144.           _DestBuffer += _AddDest;
  145.           _LeftX += _LeftDx;
  146.           _RightX += _RightDx;
  147.         } // End for
  148.     } // End else
  149. } // End of _DrawSolidNoHorz
  150.  
  151.  
  152. // VOID _DrawSolidGrdHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  153. //
  154. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  155.  
  156. VOID _DrawSolidGrdHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, 
  157.                          LONG SideClipped )
  158. {
  159.   if (SkipRow!=0)
  160.     {
  161.       _LeftX += _LeftDx*SkipRow;
  162.       _RightX += _RightDx*SkipRow;
  163.       _LeftI += _LeftDI*SkipRow;
  164.       _RightI += _RightDI*SkipRow;
  165.       _DestBuffer += _AddDest*SkipRow;
  166.     } // End if
  167.  
  168.   nColor &= 0xFF;
  169.  
  170.   LONG i,j,DrawLen;
  171.   LONG DrawLeftX,DrawRightX;
  172.   LONG DrawLeftI,DrawRightI;
  173.   BYTE *DrawBuffer;
  174.   nLoopCount -= SkipRow;
  175.  
  176.   float DivResult;
  177.   LONG ShadeOffset;
  178.  
  179.   if (!SideClipped)
  180.     {
  181.       for (i=0;i<nLoopCount;i++)
  182.         {
  183.           DrawLeftX = (_LeftX>>16);
  184.           DrawRightX = (_RightX>>16);
  185.           DrawLeftI = _LeftI;
  186.           DrawRightI = _RightI;
  187.  
  188.           DrawBuffer = _DestBuffer + DrawLeftX;
  189.           DrawLen = DrawRightX - DrawLeftX + 1;
  190.           DivResult = _DivTable[DrawLen];
  191.           //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  192.           if (DrawLen>0)
  193.             InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  194.  
  195.           for (j=0;j<DrawLen;j++)
  196.              {
  197.                ShadeOffset = (DrawLeftI>>8)&0xFF00;
  198.                *DrawBuffer = _ShadeBuffer[ShadeOffset+nColor];
  199.                DrawBuffer++;
  200.                DrawLeftI += InDeltaDI;
  201.              } // End for
  202.           _DestBuffer += _AddDest;
  203.           _LeftX += _LeftDx;
  204.           _RightX += _RightDx;
  205.           _LeftI += _LeftDI;
  206.           _RightI += _RightDI;
  207.         } // End for
  208.     } // End if
  209.   else
  210.     {
  211.       for (i=0;i<nLoopCount;i++)
  212.         {
  213.           DrawLeftX = (_LeftX>>16);
  214.           DrawRightX = (_RightX>>16);
  215.           DrawLeftI = _LeftI;
  216.           DrawRightI = _RightI;
  217.  
  218.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  219.             {
  220.               DrawLen = DrawRightX - DrawLeftX + 1;
  221.               DivResult = _DivTable[DrawLen];
  222.               TempLen = 0;
  223.               if (DrawLeftX<VMinX)
  224.                 {
  225.                   TempLen = VMinX - DrawLeftX;
  226.                   DrawLeftX = VMinX;
  227.                 } // End if
  228.               if (DrawRightX>VMaxX)
  229.                 {
  230.                   DrawRightX = VMaxX;
  231.                 } // End if
  232.  
  233.               //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  234.               if (DrawLen>0)
  235.                 InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  236.               DrawLeftI += InDeltaDI*TempLen;
  237.               DrawBuffer = _DestBuffer + DrawLeftX;
  238.               DrawLen = DrawRightX - DrawLeftX + 1;
  239.               for (j=0;j<DrawLen;j++)
  240.                 {
  241.                   ShadeOffset = (DrawLeftI>>8)&0xFF00;
  242.                   *DrawBuffer = _ShadeBuffer[ShadeOffset+nColor];
  243.                   DrawBuffer++;
  244.                   DrawLeftI += InDeltaDI;
  245.                 } // End for
  246.             } // End if
  247.  
  248.           _DestBuffer += _AddDest;
  249.           _LeftX += _LeftDx;
  250.           _RightX += _RightDx;
  251.           _LeftI += _LeftDI;
  252.           _RightI += _RightDI;
  253.         } // End for
  254.     } // End else
  255. } // End of _DrawSolidGrdHorz
  256.  
  257.  
  258. // VOID _DrawTextureNoHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  259. //
  260. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  261.  
  262. VOID _DrawTextureNoHorz ( LONG nColor, LONG nLoopCount, 
  263.                           LONG SkipRow, LONG SideClipped )
  264. {
  265.   if (SkipRow!=0)
  266.     {
  267.       _LeftX += _LeftDx*SkipRow;
  268.       _RightX += _RightDx*SkipRow;
  269.       _LeftU += _LeftDu*SkipRow;
  270.       _RightU += _RightDu*SkipRow;
  271.       _LeftV += _LeftDv*SkipRow;
  272.       _RightV += _RightDv*SkipRow;
  273.       _DestBuffer += _AddDest*SkipRow;
  274.     } // End if
  275.  
  276.   nColor &= 0xFF;
  277.  
  278.   LONG i,j,DrawLen;
  279.   LONG DrawLeftX,DrawRightX;
  280.   LONG DrawLeftU,DrawRightU;
  281.   LONG DrawLeftV,DrawRightV;
  282.   BYTE *DrawBuffer;
  283.   nLoopCount -= SkipRow;
  284.  
  285.   float DivResult;
  286.   LONG TexOffset;
  287.  
  288.   if (!SideClipped)
  289.     {
  290.       for (i=0;i<nLoopCount;i++)
  291.         {
  292.           DrawLeftX = (_LeftX>>16);
  293.           DrawRightX = (_RightX>>16);
  294.           DrawLeftU = _LeftU;
  295.           DrawRightU = _RightU;
  296.           DrawLeftV = _LeftV;
  297.           DrawRightV = _RightV;
  298.  
  299.           DrawBuffer = _DestBuffer + DrawLeftX;
  300.           DrawLen = DrawRightX - DrawLeftX + 1;
  301.           DivResult = _DivTable[DrawLen];
  302.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  303.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  304.  
  305.           for (j=0;j<DrawLen;j++)
  306.             {
  307.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  308.               *DrawBuffer = _TextureBuffer[TexOffset];
  309.               DrawBuffer++;
  310.               DrawLeftU += InDeltaDu;
  311.               DrawLeftV += InDeltaDv;
  312.             } // End for
  313.           _DestBuffer += _AddDest;
  314.           _LeftX += _LeftDx;
  315.           _RightX += _RightDx;
  316.           _LeftU += _LeftDu;
  317.           _RightU += _RightDu;
  318.           _LeftV += _LeftDv;
  319.           _RightV += _RightDv;
  320.         } // End for
  321.     } // End if
  322.   else
  323.     {
  324.       for (i=0;i<nLoopCount;i++)
  325.         {
  326.           DrawLeftX = (_LeftX>>16);
  327.           DrawRightX = (_RightX>>16);
  328.           DrawLeftU = _LeftU;
  329.           DrawRightU = _RightU;
  330.           DrawLeftV = _LeftV;
  331.           DrawRightV = _RightV;
  332.  
  333.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  334.             {
  335.               TempLen = DrawRightX - DrawLeftX + 1;
  336.               DivResult = _DivTable[TempLen];
  337.               TempLen = 0;
  338.               if (DrawLeftX<VMinX)
  339.                 {
  340.                   TempLen = VMinX - DrawLeftX;
  341.                   DrawLeftX = VMinX;
  342.                 } // End if
  343.               if (DrawRightX>VMaxX)
  344.                 {
  345.                   DrawRightX = VMaxX;
  346.                 } // End if
  347.  
  348.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  349.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  350.  
  351.               DrawLeftU += InDeltaDu*TempLen;
  352.               DrawLeftV += InDeltaDv*TempLen;
  353.  
  354.               DrawBuffer = _DestBuffer + DrawLeftX;
  355.               DrawLen = DrawRightX - DrawLeftX + 1;
  356.               for (j=0;j<DrawLen;j++)
  357.                 {
  358.                   TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  359.                   *DrawBuffer = _TextureBuffer[TexOffset];
  360.                   DrawBuffer++;
  361.                   DrawLeftU += InDeltaDu;
  362.                   DrawLeftV += InDeltaDv;
  363.                 } // End for
  364.             } // End if
  365.  
  366.           _DestBuffer += _AddDest;
  367.           _LeftX += _LeftDx;
  368.           _RightX += _RightDx;
  369.           _LeftU += _LeftDu;
  370.           _RightU += _RightDu;
  371.           _LeftV += _LeftDv;
  372.           _RightV += _RightDv;
  373.         } // End for
  374.     } // End else
  375. } // End of _DrawTextureNoHorz
  376.  
  377.  
  378. // VOID _DrawTextureFlatHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  379. //
  380. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  381.  
  382. VOID _DrawTextureFlatHorz ( LONG nColor, LONG nLoopCount, 
  383.                             LONG SkipRow, LONG SideClipped )
  384. {
  385.   if (SkipRow!=0)
  386.     {
  387.       _LeftX += _LeftDx*SkipRow;
  388.       _RightX += _RightDx*SkipRow;
  389.       _LeftU += _LeftDu*SkipRow;
  390.       _RightU += _RightDu*SkipRow;
  391.       _LeftV += _LeftDv*SkipRow;
  392.       _RightV += _RightDv*SkipRow;
  393.       _DestBuffer += _AddDest*SkipRow;
  394.     } // End if
  395.  
  396.   nColor &= 0xFF;
  397.  
  398.   LONG i,j,DrawLen;
  399.   LONG DrawLeftX,DrawRightX;
  400.   LONG DrawLeftU,DrawRightU;
  401.   LONG DrawLeftV,DrawRightV;
  402.   BYTE *DrawBuffer;
  403.   nLoopCount -= SkipRow;
  404.  
  405.   float DivResult;
  406.   LONG TexOffset;
  407.   LONG ShadeLevel;
  408.   BYTE TexColor;
  409.  
  410.   ShadeLevel = _LeftI>>8;  
  411.  
  412.   if (!SideClipped)
  413.     {
  414.       for (i=0;i<nLoopCount;i++)
  415.         {
  416.           DrawLeftX = (_LeftX>>16);
  417.           DrawRightX = (_RightX>>16);
  418.           DrawLeftU = _LeftU;
  419.           DrawRightU = _RightU;
  420.           DrawLeftV = _LeftV;
  421.           DrawRightV = _RightV;
  422.  
  423.           DrawBuffer = _DestBuffer + DrawLeftX;
  424.           DrawLen = DrawRightX - DrawLeftX + 1;
  425.           DivResult = _DivTable[DrawLen];
  426.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  427.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  428.  
  429.           for (j=0;j<DrawLen;j++)
  430.             {
  431.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  432.               TexColor = _TextureBuffer[TexOffset];
  433.               *DrawBuffer = _ShadeBuffer[ShadeLevel+TexColor];
  434.               DrawBuffer++;
  435.               DrawLeftU += InDeltaDu;
  436.               DrawLeftV += InDeltaDv;
  437.             } // End for
  438.           _DestBuffer += _AddDest;
  439.           _LeftX += _LeftDx;
  440.           _RightX += _RightDx;
  441.           _LeftU += _LeftDu;
  442.           _RightU += _RightDu;
  443.           _LeftV += _LeftDv;
  444.           _RightV += _RightDv;
  445.         } // End for
  446.     } // End if
  447.   else
  448.     {
  449.       for (i=0;i<nLoopCount;i++)
  450.         {
  451.           DrawLeftX = (_LeftX>>16);
  452.           DrawRightX = (_RightX>>16);
  453.           DrawLeftU = _LeftU;
  454.           DrawRightU = _RightU;
  455.           DrawLeftV = _LeftV;
  456.           DrawRightV = _RightV;
  457.  
  458.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  459.             {
  460.               TempLen = DrawRightX - DrawLeftX + 1;
  461.               DivResult = _DivTable[TempLen];
  462.               TempLen = 0;
  463.               if (DrawLeftX<VMinX)
  464.                 {
  465.                   TempLen = VMinX - DrawLeftX;
  466.                   DrawLeftX = VMinX;
  467.                 } // End if
  468.               if (DrawRightX>VMaxX)
  469.                 {
  470.                   DrawRightX = VMaxX;
  471.                 } // End if
  472.  
  473.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  474.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  475.  
  476.               DrawLeftU += InDeltaDu*TempLen;
  477.               DrawLeftV += InDeltaDv*TempLen;
  478.  
  479.               DrawBuffer = _DestBuffer + DrawLeftX;
  480.               DrawLen = DrawRightX - DrawLeftX + 1;
  481.               for (j=0;j<DrawLen;j++)
  482.                 {
  483.                   TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  484.                   TexColor = _TextureBuffer[TexOffset];
  485.                   *DrawBuffer = _ShadeBuffer[ShadeLevel+TexColor];
  486.                   DrawBuffer++;
  487.                   DrawLeftU += InDeltaDu;
  488.                   DrawLeftV += InDeltaDv;
  489.                 } // End for
  490.             } // End if
  491.  
  492.           _DestBuffer += _AddDest;
  493.           _LeftX += _LeftDx;
  494.           _RightX += _RightDx;
  495.           _LeftU += _LeftDu;
  496.           _RightU += _RightDu;
  497.           _LeftV += _LeftDv;
  498.           _RightV += _RightDv;
  499.         } // End for
  500.     } // End else
  501. } // End of _DrawTextureFlatHorz
  502.  
  503.  
  504. // VOID _DrawTextureGrdHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  505. //
  506. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  507.  
  508. VOID _DrawTextureGrdHorz ( LONG nColor, LONG nLoopCount, 
  509.                            LONG SkipRow, LONG SideClipped )
  510. {
  511.   if (SkipRow!=0)
  512.     {
  513.       _LeftX += _LeftDx*SkipRow;
  514.       _RightX += _RightDx*SkipRow;
  515.       _LeftU += _LeftDu*SkipRow;
  516.       _RightU += _RightDu*SkipRow;
  517.       _LeftV += _LeftDv*SkipRow;
  518.       _RightV += _RightDv*SkipRow;
  519.       _LeftI += _LeftDI*SkipRow;
  520.       _RightI += _RightDI*SkipRow;
  521.       _DestBuffer += _AddDest*SkipRow;
  522.     } // End if
  523.  
  524.   nColor &= 0xFF;
  525.  
  526.   LONG i,j,DrawLen;
  527.   LONG DrawLeftX,DrawRightX;
  528.   LONG DrawLeftU,DrawRightU;
  529.   LONG DrawLeftV,DrawRightV;
  530.   LONG DrawLeftI,DrawRightI;
  531.   BYTE *DrawBuffer;
  532.   nLoopCount -= SkipRow;
  533.  
  534.   float DivResult;
  535.   LONG TexOffset;
  536.   LONG ShadeLevel;
  537.   BYTE TexColor;
  538.  
  539.   ShadeLevel = _LeftI>>8;  
  540.  
  541.   if (!SideClipped)
  542.     {
  543.       for (i=0;i<nLoopCount;i++)
  544.         {
  545.           DrawLeftX = (_LeftX>>16);
  546.           DrawRightX = (_RightX>>16);
  547.           DrawLeftU = _LeftU;
  548.           DrawRightU = _RightU;
  549.           DrawLeftV = _LeftV;
  550.           DrawRightV = _RightV;
  551.           DrawLeftI = _LeftI;
  552.           DrawRightI = _RightI;
  553.  
  554.           DrawBuffer = _DestBuffer + DrawLeftX;
  555.           DrawLen = DrawRightX - DrawLeftX + 1;
  556.           DivResult = _DivTable[DrawLen];
  557.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  558.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  559.           //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  560.           if (DrawLen>0)
  561.             InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  562.  
  563.           for (j=0;j<DrawLen;j++)
  564.             {
  565.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  566.               TexColor = _TextureBuffer[TexOffset];
  567.               ShadeLevel = (DrawLeftI>>8)&0xFF00;
  568.               *DrawBuffer = _ShadeBuffer[ShadeLevel+TexColor];
  569.               DrawBuffer++;
  570.               DrawLeftU += InDeltaDu;
  571.               DrawLeftV += InDeltaDv;
  572.               DrawLeftI += InDeltaDI;
  573.             } // End for
  574.           _DestBuffer += _AddDest;
  575.           _LeftX += _LeftDx;
  576.           _RightX += _RightDx;
  577.           _LeftU += _LeftDu;
  578.           _RightU += _RightDu;
  579.           _LeftV += _LeftDv;
  580.           _RightV += _RightDv;
  581.           _LeftI += _LeftDI;
  582.           _RightI += _RightDI;
  583.         } // End for
  584.     } // End if
  585.   else
  586.     {
  587.       for (i=0;i<nLoopCount;i++)
  588.         {
  589.           DrawLeftX = (_LeftX>>16);
  590.           DrawRightX = (_RightX>>16);
  591.           DrawLeftU = _LeftU;
  592.           DrawRightU = _RightU;
  593.           DrawLeftV = _LeftV;
  594.           DrawRightV = _RightV;
  595.           DrawLeftI = _LeftI;
  596.           DrawRightI = _RightI;
  597.  
  598.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  599.             {
  600.               DrawLen = DrawRightX - DrawLeftX + 1;
  601.               DivResult = _DivTable[DrawLen];
  602.               TempLen = 0;
  603.               if (DrawLeftX<VMinX)
  604.                 {
  605.                   TempLen = VMinX - DrawLeftX;
  606.                   DrawLeftX = VMinX;
  607.                 } // End if
  608.               if (DrawRightX>VMaxX)
  609.                 {
  610.                   DrawRightX = VMaxX;
  611.                 } // End if
  612.  
  613.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  614.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  615.               //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  616.               if (DrawLen>0)
  617.                 InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  618.  
  619.                DrawLeftU += InDeltaDu*TempLen;
  620.                DrawLeftV += InDeltaDv*TempLen;
  621.                DrawLeftI += InDeltaDI*TempLen;
  622.  
  623.                DrawBuffer = _DestBuffer + DrawLeftX;
  624.                DrawLen = DrawRightX - DrawLeftX + 1;
  625.                for (j=0;j<DrawLen;j++)
  626.                  {
  627.                    TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  628.                    TexColor = _TextureBuffer[TexOffset];
  629.                    ShadeLevel = (DrawLeftI>>8)&0xFF00;
  630.                    *DrawBuffer = _ShadeBuffer[ShadeLevel+TexColor];
  631.                    DrawBuffer++;
  632.                    DrawLeftU += InDeltaDu;
  633.                    DrawLeftV += InDeltaDv;
  634.                    DrawLeftI += InDeltaDI;
  635.                  } // End for
  636.              } // End if
  637.  
  638.            _DestBuffer += _AddDest;
  639.            _LeftX += _LeftDx;
  640.            _RightX += _RightDx;
  641.            _LeftU += _LeftDu;
  642.            _RightU += _RightDu;
  643.            _LeftV += _LeftDv;
  644.            _RightV += _RightDv;
  645.            _LeftI += _LeftDI;
  646.            _RightI += _RightDI;
  647.          } // End for
  648.      } // End else
  649. } // End of _DrawTextureGrdHorz
  650.  
  651.  
  652. // VOID _DrawSolidNoTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  653. //
  654. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  655.  
  656. VOID _DrawSolidNoTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  657.                              LONG SideClipped )
  658. {
  659.   nColor = nColor & 0x00FF;
  660.     
  661.   if (SkipRow!=0)
  662.     {
  663.       _LeftX += _LeftDx*SkipRow;
  664.       _RightX += _RightDx*SkipRow;
  665.       _DestBuffer += _AddDest*SkipRow;
  666.     } // End if
  667.  
  668.   LONG i,j,DrawLen;
  669.   LONG DrawLeftX,DrawRightX;
  670.   BYTE *DrawBuffer;
  671.   nLoopCount -= SkipRow;
  672.   LONG bColor;
  673.  
  674.   nColor <<= 8;
  675.    
  676.   if (!SideClipped)
  677.     {
  678.       for (i=0;i<nLoopCount;i++)
  679.         {
  680.           DrawLeftX = (_LeftX>>16);
  681.           DrawRightX = (_RightX>>16);
  682.           DrawBuffer = _DestBuffer + DrawLeftX;
  683.           DrawLen = DrawRightX - DrawLeftX + 1;
  684.           for (j=0;j<DrawLen;j++)
  685.             {
  686.               bColor = *DrawBuffer;
  687.               *DrawBuffer = (BYTE)_BlendBuffer[nColor+bColor];
  688.               DrawBuffer++;
  689.             } // End for
  690.           _DestBuffer += _AddDest;
  691.           _LeftX += _LeftDx;
  692.           _RightX += _RightDx;
  693.         } // End for
  694.     } // End if
  695.   else
  696.     {
  697.       for (i=0;i<nLoopCount;i++)
  698.         {
  699.           DrawLeftX = (_LeftX>>16);
  700.           DrawRightX = (_RightX>>16);
  701.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  702.             {
  703.               if (DrawLeftX<VMinX)
  704.                 {
  705.                   DrawLeftX = VMinX;
  706.                 } // End if
  707.               if (DrawRightX>VMaxX)
  708.                 {
  709.                   DrawRightX = VMaxX;
  710.                 } // End if
  711.  
  712.               DrawBuffer = _DestBuffer + DrawLeftX;
  713.               DrawLen = DrawRightX - DrawLeftX + 1;
  714.               for (j=0;j<DrawLen;j++)
  715.                 {
  716.                   bColor = *DrawBuffer;
  717.                   *DrawBuffer = (BYTE)_BlendBuffer[nColor+bColor];
  718.                   DrawBuffer++;
  719.                 } // End for
  720.             } // End if
  721.           _DestBuffer += _AddDest;
  722.           _LeftX += _LeftDx;
  723.           _RightX += _RightDx;
  724.         } // End for
  725.     } // End else
  726. } // End of _DrawSolidNoTransHorz 
  727.                              
  728.  
  729. // VOID _DrawSolidGrdTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  730. //
  731. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  732.  
  733. VOID _DrawSolidGrdTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  734.                               LONG SideClipped )
  735. {
  736.   nColor = nColor & 0x00FF;
  737.   
  738.   if (SkipRow!=0)
  739.     {
  740.       _LeftX += _LeftDx*SkipRow;
  741.       _RightX += _RightDx*SkipRow;
  742.       _LeftI += _LeftDI*SkipRow;
  743.       _RightI += _RightDI*SkipRow;
  744.       _DestBuffer += _AddDest*SkipRow;
  745.     } // End if
  746.  
  747.   nColor &= 0xFF;
  748.  
  749.   LONG i,j,DrawLen;
  750.   LONG DrawLeftX,DrawRightX;
  751.   LONG DrawLeftI,DrawRightI;
  752.   BYTE *DrawBuffer;
  753.   nLoopCount -= SkipRow;
  754.  
  755.   float DivResult;
  756.   LONG ShadeOffset;
  757.   LONG bColor;
  758.   LONG fColor;
  759.  
  760.   if (!SideClipped)
  761.     {
  762.       for (i=0;i<nLoopCount;i++)
  763.         {
  764.           DrawLeftX = (_LeftX>>16);
  765.           DrawRightX = (_RightX>>16);
  766.           DrawLeftI = _LeftI;
  767.           DrawRightI = _RightI;
  768.  
  769.           DrawBuffer = _DestBuffer + DrawLeftX;
  770.           DrawLen = DrawRightX - DrawLeftX + 1;
  771.           DivResult = _DivTable[DrawLen];
  772.           //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  773.           if (DrawLen>0)
  774.             InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  775.  
  776.           for (j=0;j<DrawLen;j++)
  777.              {
  778.                ShadeOffset = (DrawLeftI>>8)&0xFF00;
  779.                bColor = *DrawBuffer;
  780.                fColor = _ShadeBuffer[ShadeOffset+nColor];
  781.                *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  782.                DrawBuffer++;
  783.                DrawLeftI += InDeltaDI;
  784.              } // End for
  785.           _DestBuffer += _AddDest;
  786.           _LeftX += _LeftDx;
  787.           _RightX += _RightDx;
  788.           _LeftI += _LeftDI;
  789.           _RightI += _RightDI;
  790.         } // End for
  791.     } // End if
  792.   else
  793.     {
  794.       for (i=0;i<nLoopCount;i++)
  795.         {
  796.           DrawLeftX = (_LeftX>>16);
  797.           DrawRightX = (_RightX>>16);
  798.           DrawLeftI = _LeftI;
  799.           DrawRightI = _RightI;
  800.  
  801.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  802.             {
  803.               DrawLen = DrawRightX - DrawLeftX + 1;
  804.               DivResult = _DivTable[DrawLen];
  805.               TempLen = 0;
  806.               if (DrawLeftX<VMinX)
  807.                 {
  808.                   TempLen = VMinX - DrawLeftX;
  809.                   DrawLeftX = VMinX;
  810.                 } // End if
  811.               if (DrawRightX>VMaxX)
  812.                 {
  813.                   DrawRightX = VMaxX;
  814.                 } // End if
  815.  
  816.               //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  817.               if (DrawLen>0)
  818.                 InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  819.               DrawLeftI += InDeltaDI*TempLen;
  820.               DrawBuffer = _DestBuffer + DrawLeftX;
  821.               DrawLen = DrawRightX - DrawLeftX + 1;
  822.               for (j=0;j<DrawLen;j++)
  823.                 {
  824.                   ShadeOffset = (DrawLeftI>>8)&0xFF00;
  825.                   bColor = *DrawBuffer;
  826.                   fColor = _ShadeBuffer[ShadeOffset+nColor];
  827.                   *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  828.                   DrawBuffer++;
  829.                   DrawLeftI += InDeltaDI;
  830.                 } // End for
  831.             } // End if
  832.  
  833.           _DestBuffer += _AddDest;
  834.           _LeftX += _LeftDx;
  835.           _RightX += _RightDx;
  836.           _LeftI += _LeftDI;
  837.           _RightI += _RightDI;
  838.         } // End for
  839.     } // End else
  840. } // End of _DrawSolidGrdTransHorz 
  841.                              
  842.  
  843. // VOID _DrawTextureNoTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  844. //
  845. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  846.  
  847. VOID _DrawTextureNoTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  848.                                LONG SideClipped )
  849. {
  850.   if (SkipRow!=0)
  851.     {
  852.       _LeftX += _LeftDx*SkipRow;
  853.       _RightX += _RightDx*SkipRow;
  854.       _LeftU += _LeftDu*SkipRow;
  855.       _RightU += _RightDu*SkipRow;
  856.       _LeftV += _LeftDv*SkipRow;
  857.       _RightV += _RightDv*SkipRow;
  858.       _DestBuffer += _AddDest*SkipRow;
  859.     } // End if
  860.  
  861.   nColor &= 0xFF;
  862.  
  863.   LONG i,j,DrawLen;
  864.   LONG DrawLeftX,DrawRightX;
  865.   LONG DrawLeftU,DrawRightU;
  866.   LONG DrawLeftV,DrawRightV;
  867.   BYTE *DrawBuffer;
  868.   nLoopCount -= SkipRow;
  869.  
  870.   float DivResult;
  871.   LONG TexOffset;
  872.   LONG bColor;
  873.   LONG fColor;
  874.  
  875.   if (!SideClipped)
  876.     {
  877.       for (i=0;i<nLoopCount;i++)
  878.         {
  879.           DrawLeftX = (_LeftX>>16);
  880.           DrawRightX = (_RightX>>16);
  881.           DrawLeftU = _LeftU;
  882.           DrawRightU = _RightU;
  883.           DrawLeftV = _LeftV;
  884.           DrawRightV = _RightV;
  885.  
  886.           DrawBuffer = _DestBuffer + DrawLeftX;
  887.           DrawLen = DrawRightX - DrawLeftX + 1;
  888.           DivResult = _DivTable[DrawLen];
  889.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  890.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  891.  
  892.           for (j=0;j<DrawLen;j++)
  893.             {
  894.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  895.               bColor = *DrawBuffer;
  896.               fColor = _TextureBuffer[TexOffset];
  897.               *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  898.               DrawBuffer++;
  899.               DrawLeftU += InDeltaDu;
  900.               DrawLeftV += InDeltaDv;
  901.             } // End for
  902.           _DestBuffer += _AddDest;
  903.           _LeftX += _LeftDx;
  904.           _RightX += _RightDx;
  905.           _LeftU += _LeftDu;
  906.           _RightU += _RightDu;
  907.           _LeftV += _LeftDv;
  908.           _RightV += _RightDv;
  909.         } // End for
  910.     } // End if
  911.   else
  912.     {
  913.       for (i=0;i<nLoopCount;i++)
  914.         {
  915.           DrawLeftX = (_LeftX>>16);
  916.           DrawRightX = (_RightX>>16);
  917.           DrawLeftU = _LeftU;
  918.           DrawRightU = _RightU;
  919.           DrawLeftV = _LeftV;
  920.           DrawRightV = _RightV;
  921.  
  922.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  923.             {
  924.               TempLen = DrawRightX - DrawLeftX + 1;
  925.               DivResult = _DivTable[TempLen];
  926.               TempLen = 0;
  927.               if (DrawLeftX<VMinX)
  928.                 {
  929.                   TempLen = VMinX - DrawLeftX;
  930.                   DrawLeftX = VMinX;
  931.                 } // End if
  932.               if (DrawRightX>VMaxX)
  933.                 {
  934.                   DrawRightX = VMaxX;
  935.                 } // End if
  936.  
  937.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  938.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  939.  
  940.               DrawLeftU += InDeltaDu*TempLen;
  941.               DrawLeftV += InDeltaDv*TempLen;
  942.  
  943.               DrawBuffer = _DestBuffer + DrawLeftX;
  944.               DrawLen = DrawRightX - DrawLeftX + 1;
  945.               for (j=0;j<DrawLen;j++)
  946.                 {
  947.                   TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  948.                   bColor = *DrawBuffer;
  949.                   fColor = _TextureBuffer[TexOffset];
  950.                   *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  951.                   DrawBuffer++;
  952.                   DrawLeftU += InDeltaDu;
  953.                   DrawLeftV += InDeltaDv;
  954.                 } // End for
  955.             } // End if
  956.  
  957.           _DestBuffer += _AddDest;
  958.           _LeftX += _LeftDx;
  959.           _RightX += _RightDx;
  960.           _LeftU += _LeftDu;
  961.           _RightU += _RightDu;
  962.           _LeftV += _LeftDv;
  963.           _RightV += _RightDv;
  964.         } // End for
  965.     } // End else
  966. } // End of _DrawTextureNoTransHorz
  967.                              
  968.  
  969. // VOID _DrawTextureFlatTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  970. //
  971. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  972.  
  973. VOID _DrawTextureFlatTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  974.                                  LONG SideClipped )
  975. {
  976.   if (SkipRow!=0)
  977.     {
  978.       _LeftX += _LeftDx*SkipRow;
  979.       _RightX += _RightDx*SkipRow;
  980.       _LeftU += _LeftDu*SkipRow;
  981.       _RightU += _RightDu*SkipRow;
  982.       _LeftV += _LeftDv*SkipRow;
  983.       _RightV += _RightDv*SkipRow;
  984.       _DestBuffer += _AddDest*SkipRow;
  985.     } // End if
  986.  
  987.   nColor &= 0xFF;
  988.  
  989.   LONG i,j,DrawLen;
  990.   LONG DrawLeftX,DrawRightX;
  991.   LONG DrawLeftU,DrawRightU;
  992.   LONG DrawLeftV,DrawRightV;
  993.   BYTE *DrawBuffer;
  994.   nLoopCount -= SkipRow;
  995.  
  996.   float DivResult;
  997.   LONG TexOffset;
  998.   LONG ShadeLevel;
  999.   BYTE TexColor;
  1000.   LONG bColor;
  1001.   LONG fColor;
  1002.  
  1003.   ShadeLevel = _LeftI>>8;  
  1004.  
  1005.   if (!SideClipped)
  1006.     {
  1007.       for (i=0;i<nLoopCount;i++)
  1008.         {
  1009.           DrawLeftX = (_LeftX>>16);
  1010.           DrawRightX = (_RightX>>16);
  1011.           DrawLeftU = _LeftU;
  1012.           DrawRightU = _RightU;
  1013.           DrawLeftV = _LeftV;
  1014.           DrawRightV = _RightV;
  1015.  
  1016.           DrawBuffer = _DestBuffer + DrawLeftX;
  1017.           DrawLen = DrawRightX - DrawLeftX + 1;
  1018.           DivResult = _DivTable[DrawLen];
  1019.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1020.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1021.  
  1022.           for (j=0;j<DrawLen;j++)
  1023.             {
  1024.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1025.               TexColor = _TextureBuffer[TexOffset];
  1026.               bColor = *DrawBuffer;
  1027.               fColor = _ShadeBuffer[ShadeLevel+TexColor];
  1028.               *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  1029.               DrawBuffer++;
  1030.               DrawLeftU += InDeltaDu;
  1031.               DrawLeftV += InDeltaDv;
  1032.             } // End for
  1033.           _DestBuffer += _AddDest;
  1034.           _LeftX += _LeftDx;
  1035.           _RightX += _RightDx;
  1036.           _LeftU += _LeftDu;
  1037.           _RightU += _RightDu;
  1038.           _LeftV += _LeftDv;
  1039.           _RightV += _RightDv;
  1040.         } // End for
  1041.     } // End if
  1042.   else
  1043.     {
  1044.       for (i=0;i<nLoopCount;i++)
  1045.         {
  1046.           DrawLeftX = (_LeftX>>16);
  1047.           DrawRightX = (_RightX>>16);
  1048.           DrawLeftU = _LeftU;
  1049.           DrawRightU = _RightU;
  1050.           DrawLeftV = _LeftV;
  1051.           DrawRightV = _RightV;
  1052.  
  1053.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  1054.             {
  1055.               TempLen = DrawRightX - DrawLeftX + 1;
  1056.               DivResult = _DivTable[TempLen];
  1057.               TempLen = 0;
  1058.               if (DrawLeftX<VMinX)
  1059.                 {
  1060.                   TempLen = VMinX - DrawLeftX;
  1061.                   DrawLeftX = VMinX;
  1062.                 } // End if
  1063.               if (DrawRightX>VMaxX)
  1064.                 {
  1065.                   DrawRightX = VMaxX;
  1066.                 } // End if
  1067.  
  1068.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1069.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1070.  
  1071.               DrawLeftU += InDeltaDu*TempLen;
  1072.               DrawLeftV += InDeltaDv*TempLen;
  1073.  
  1074.               DrawBuffer = _DestBuffer + DrawLeftX;
  1075.               DrawLen = DrawRightX - DrawLeftX + 1;
  1076.               for (j=0;j<DrawLen;j++)
  1077.                 {
  1078.                   TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1079.                   TexColor = _TextureBuffer[TexOffset];
  1080.                   bColor = *DrawBuffer;
  1081.                   fColor = _ShadeBuffer[ShadeLevel+TexColor];
  1082.                   *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  1083.                   DrawBuffer++;
  1084.                   DrawLeftU += InDeltaDu;
  1085.                   DrawLeftV += InDeltaDv;
  1086.                 } // End for
  1087.             } // End if
  1088.  
  1089.           _DestBuffer += _AddDest;
  1090.           _LeftX += _LeftDx;
  1091.           _RightX += _RightDx;
  1092.           _LeftU += _LeftDu;
  1093.           _RightU += _RightDu;
  1094.           _LeftV += _LeftDv;
  1095.           _RightV += _RightDv;
  1096.         } // End for
  1097.     } // End else
  1098. } // End of _DrawTextureFlatTransHorz
  1099.                              
  1100.  
  1101. // VOID _DrawTextureGrdTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  1102. //
  1103. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  1104.  
  1105. VOID _DrawTextureGrdTransHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  1106.                                 LONG SideClipped )
  1107. {
  1108.   if (SkipRow!=0)
  1109.     {
  1110.       _LeftX += _LeftDx*SkipRow;
  1111.       _RightX += _RightDx*SkipRow;
  1112.       _LeftU += _LeftDu*SkipRow;
  1113.       _RightU += _RightDu*SkipRow;
  1114.       _LeftV += _LeftDv*SkipRow;
  1115.       _RightV += _RightDv*SkipRow;
  1116.       _LeftI += _LeftDI*SkipRow;
  1117.       _RightI += _RightDI*SkipRow;
  1118.       _DestBuffer += _AddDest*SkipRow;
  1119.     } // End if
  1120.  
  1121.   nColor &= 0xFF;
  1122.  
  1123.   LONG i,j,DrawLen;
  1124.   LONG DrawLeftX,DrawRightX;
  1125.   LONG DrawLeftU,DrawRightU;
  1126.   LONG DrawLeftV,DrawRightV;
  1127.   LONG DrawLeftI,DrawRightI;
  1128.   BYTE *DrawBuffer;
  1129.   nLoopCount -= SkipRow;
  1130.  
  1131.   float DivResult;
  1132.   LONG TexOffset;
  1133.   LONG ShadeLevel;
  1134.   BYTE TexColor;
  1135.   LONG bColor;
  1136.   LONG fColor;
  1137.  
  1138.   ShadeLevel = _LeftI>>8;  
  1139.  
  1140.   if (!SideClipped)
  1141.     {
  1142.       for (i=0;i<nLoopCount;i++)
  1143.         {
  1144.           DrawLeftX = (_LeftX>>16);
  1145.           DrawRightX = (_RightX>>16);
  1146.           DrawLeftU = _LeftU;
  1147.           DrawRightU = _RightU;
  1148.           DrawLeftV = _LeftV;
  1149.           DrawRightV = _RightV;
  1150.           DrawLeftI = _LeftI;
  1151.           DrawRightI = _RightI;
  1152.  
  1153.           DrawBuffer = _DestBuffer + DrawLeftX;
  1154.           DrawLen = DrawRightX - DrawLeftX + 1;
  1155.           DivResult = _DivTable[DrawLen];
  1156.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1157.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1158.           //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1159.           if (DrawLen>0)
  1160.             InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  1161.  
  1162.           for (j=0;j<DrawLen;j++)
  1163.             {
  1164.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1165.               TexColor = _TextureBuffer[TexOffset];
  1166.               bColor = *DrawBuffer;
  1167.               ShadeLevel = (DrawLeftI>>8)&0xFF00;
  1168.               fColor = _ShadeBuffer[ShadeLevel+TexColor];
  1169.               *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  1170.               DrawBuffer++;
  1171.               DrawLeftU += InDeltaDu;
  1172.               DrawLeftV += InDeltaDv;
  1173.               DrawLeftI += InDeltaDI;
  1174.             } // End for
  1175.           _DestBuffer += _AddDest;
  1176.           _LeftX += _LeftDx;
  1177.           _RightX += _RightDx;
  1178.           _LeftU += _LeftDu;
  1179.           _RightU += _RightDu;
  1180.           _LeftV += _LeftDv;
  1181.           _RightV += _RightDv;
  1182.           _LeftI += _LeftDI;
  1183.           _RightI += _RightDI;
  1184.         } // End for
  1185.     } // End if
  1186.   else
  1187.     {
  1188.       for (i=0;i<nLoopCount;i++)
  1189.         {
  1190.           DrawLeftX = (_LeftX>>16);
  1191.           DrawRightX = (_RightX>>16);
  1192.           DrawLeftU = _LeftU;
  1193.           DrawRightU = _RightU;
  1194.           DrawLeftV = _LeftV;
  1195.           DrawRightV = _RightV;
  1196.           DrawLeftI = _LeftI;
  1197.           DrawRightI = _RightI;
  1198.  
  1199.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  1200.             {
  1201.               DrawLen = DrawRightX - DrawLeftX + 1;
  1202.               DivResult = _DivTable[DrawLen];
  1203.               TempLen = 0;
  1204.               if (DrawLeftX<VMinX)
  1205.                 {
  1206.                   TempLen = VMinX - DrawLeftX;
  1207.                   DrawLeftX = VMinX;
  1208.                 } // End if
  1209.               if (DrawRightX>VMaxX)
  1210.                 {
  1211.                   DrawRightX = VMaxX;
  1212.                 } // End if
  1213.  
  1214.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1215.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1216.               //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1217.               if (DrawLen>0)
  1218.                 InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  1219.  
  1220.                DrawLeftU += InDeltaDu*TempLen;
  1221.                DrawLeftV += InDeltaDv*TempLen;
  1222.                DrawLeftI += InDeltaDI*TempLen;
  1223.  
  1224.                DrawBuffer = _DestBuffer + DrawLeftX;
  1225.                DrawLen = DrawRightX - DrawLeftX + 1;
  1226.                for (j=0;j<DrawLen;j++)
  1227.                  {
  1228.                    TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1229.                    TexColor = _TextureBuffer[TexOffset];
  1230.                    bColor = *DrawBuffer;
  1231.                    ShadeLevel = (DrawLeftI>>8)&0xFF00;
  1232.                    fColor = _ShadeBuffer[ShadeLevel+TexColor];
  1233.                    *DrawBuffer = _BlendBuffer[(fColor<<8)+bColor];
  1234.                    DrawBuffer++;
  1235.                    DrawLeftU += InDeltaDu;
  1236.                    DrawLeftV += InDeltaDv;
  1237.                    DrawLeftI += InDeltaDI;
  1238.                  } // End for
  1239.              } // End if
  1240.  
  1241.            _DestBuffer += _AddDest;
  1242.            _LeftX += _LeftDx;
  1243.            _RightX += _RightDx;
  1244.            _LeftU += _LeftDu;
  1245.            _RightU += _RightDu;
  1246.            _LeftV += _LeftDv;
  1247.            _RightV += _RightDv;
  1248.            _LeftI += _LeftDI;
  1249.            _RightI += _RightDI;
  1250.          } // End for
  1251.      } // End else
  1252. } // End of _DrawTextureGrdTransHorz
  1253.                              
  1254.                                       
  1255.  
  1256. // VOID _DrawSolidNoHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  1257. //
  1258. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  1259.  
  1260. VOID _DrawSolidNoHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  1261.                             LONG SideClipped )
  1262. {
  1263.   if (SkipRow!=0)
  1264.     {
  1265.       _LeftX += _LeftDx*SkipRow;
  1266.       _RightX += _RightDx*SkipRow;
  1267.       _LeftH += _LeftDh*SkipRow;
  1268.       _RightH += _RightDh*SkipRow;
  1269.       _DestBuffer += _AddDest*SkipRow;
  1270.     } // End if
  1271.  
  1272.   nColor &= 0xFF;
  1273.  
  1274.   LONG i,j,DrawLen;
  1275.   LONG DrawLeftX,DrawRightX;
  1276.   LONG DrawLeftH,DrawRightH;
  1277.   BYTE *DrawBuffer;
  1278.   nLoopCount -= SkipRow;
  1279.  
  1280.   float DivResult;
  1281.   LONG HazeOffset;
  1282.  
  1283.   if (!SideClipped)
  1284.     {
  1285.       for (i=0;i<nLoopCount;i++)
  1286.         {
  1287.           DrawLeftX = (_LeftX>>16);
  1288.           DrawRightX = (_RightX>>16);
  1289.           DrawLeftH = _LeftH;
  1290.           DrawRightH = _RightH;
  1291.  
  1292.           DrawBuffer = _DestBuffer + DrawLeftX;
  1293.           DrawLen = DrawRightX - DrawLeftX + 1;
  1294.           DivResult = _DivTable[DrawLen];
  1295.           //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1296.           if (DrawLen>0)
  1297.             InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1298.  
  1299.           for (j=0;j<DrawLen;j++)
  1300.              {
  1301.                HazeOffset = (DrawLeftH>>8)&0xFF00;
  1302.                *DrawBuffer = _HazeBuffer[HazeOffset+nColor];
  1303.                DrawBuffer++;
  1304.                DrawLeftH += InDeltaDh;
  1305.              } // End for
  1306.           _DestBuffer += _AddDest;
  1307.           _LeftX += _LeftDx;
  1308.           _RightX += _RightDx;
  1309.           _LeftH += _LeftDh;
  1310.           _RightH += _RightDh;
  1311.         } // End for
  1312.     } // End if
  1313.   else
  1314.     {
  1315.       for (i=0;i<nLoopCount;i++)
  1316.         {
  1317.           DrawLeftX = (_LeftX>>16);
  1318.           DrawRightX = (_RightX>>16);
  1319.           DrawLeftH = _LeftH;
  1320.           DrawRightH = _RightH;
  1321.  
  1322.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  1323.             {
  1324.               DrawLen = DrawRightX - DrawLeftX + 1;
  1325.               DivResult = _DivTable[DrawLen];
  1326.               TempLen = 0;
  1327.               if (DrawLeftX<VMinX)
  1328.                 {
  1329.                   TempLen = VMinX - DrawLeftX;
  1330.                   DrawLeftX = VMinX;
  1331.                 } // End if
  1332.               if (DrawRightX>VMaxX)
  1333.                 {
  1334.                   DrawRightX = VMaxX;
  1335.                 } // End if
  1336.  
  1337.               //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1338.               if (DrawLen>0)
  1339.                 InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1340.               DrawLeftH += InDeltaDh*TempLen;
  1341.               DrawBuffer = _DestBuffer + DrawLeftX;
  1342.               DrawLen = DrawRightX - DrawLeftX + 1;
  1343.               for (j=0;j<DrawLen;j++)
  1344.                 {
  1345.                   HazeOffset = (DrawLeftH>>8)&0xFF00;
  1346.                   *DrawBuffer = _HazeBuffer[HazeOffset+nColor];
  1347.                   DrawBuffer++;
  1348.                   DrawLeftH += InDeltaDh;
  1349.                 } // End for
  1350.             } // End if
  1351.  
  1352.           _DestBuffer += _AddDest;
  1353.           _LeftX += _LeftDx;
  1354.           _RightX += _RightDx;
  1355.           _LeftH += _LeftDh;
  1356.           _RightH += _RightDh;
  1357.         } // End for
  1358.     } // End else
  1359. } // End of _DrawSolidNoHazeHorz
  1360.                              
  1361.  
  1362. // VOID _DrawSolidGrdHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  1363. //
  1364. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  1365.  
  1366. VOID _DrawSolidGrdHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  1367.                              LONG SideClipped )
  1368. {
  1369.   if (SkipRow!=0)
  1370.     {
  1371.       _LeftX += _LeftDx*SkipRow;
  1372.       _RightX += _RightDx*SkipRow;
  1373.       _LeftI += _LeftDI*SkipRow;
  1374.       _RightI += _RightDI*SkipRow;
  1375.       _LeftH += _LeftDh*SkipRow;
  1376.       _RightH += _RightDh*SkipRow;
  1377.       _DestBuffer += _AddDest*SkipRow;
  1378.     } // End if
  1379.  
  1380.   nColor &= 0xFF;
  1381.  
  1382.   LONG i,j,DrawLen;
  1383.   LONG DrawLeftX,DrawRightX;
  1384.   LONG DrawLeftI,DrawRightI;
  1385.   LONG DrawLeftH,DrawRightH;
  1386.   BYTE *DrawBuffer;
  1387.   nLoopCount -= SkipRow;
  1388.  
  1389.   float DivResult;
  1390.   LONG ShadeOffset;
  1391.   LONG HazeOffset;
  1392.  
  1393.   if (!SideClipped)
  1394.     {
  1395.       for (i=0;i<nLoopCount;i++)
  1396.         {
  1397.           DrawLeftX = (_LeftX>>16);
  1398.           DrawRightX = (_RightX>>16);
  1399.           DrawLeftI = _LeftI;
  1400.           DrawRightI = _RightI;
  1401.           DrawLeftH = _LeftH;
  1402.           DrawRightH = _RightH;
  1403.  
  1404.           DrawBuffer = _DestBuffer + DrawLeftX;
  1405.           DrawLen = DrawRightX - DrawLeftX + 1;
  1406.           DivResult = _DivTable[DrawLen];
  1407.           //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1408.           if (DrawLen>0)
  1409.             {
  1410.               InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  1411.               InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1412.             } // End if
  1413.  
  1414.           for (j=0;j<DrawLen;j++)
  1415.              {
  1416.                ShadeOffset = (DrawLeftI>>8)&0xFF00;
  1417.                HazeOffset = ((DrawLeftH>>8)&0xFF00) + _ShadeBuffer[ShadeOffset+nColor];
  1418.                *DrawBuffer = _HazeBuffer[HazeOffset];
  1419.                DrawBuffer++;
  1420.                DrawLeftI += InDeltaDI;
  1421.                DrawLeftH += InDeltaDh;
  1422.              } // End for
  1423.           _DestBuffer += _AddDest;
  1424.           _LeftX += _LeftDx;
  1425.           _RightX += _RightDx;
  1426.           _LeftI += _LeftDI;
  1427.           _RightI += _RightDI;
  1428.           _LeftH += _LeftDh;
  1429.           _RightH += _RightDh;
  1430.         } // End for
  1431.     } // End if
  1432.   else
  1433.     {
  1434.       for (i=0;i<nLoopCount;i++)
  1435.         {
  1436.           DrawLeftX = (_LeftX>>16);
  1437.           DrawRightX = (_RightX>>16);
  1438.           DrawLeftI = _LeftI;
  1439.           DrawRightI = _RightI;
  1440.           DrawLeftH = _LeftH;
  1441.           DrawRightH = _RightH;
  1442.  
  1443.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  1444.             {
  1445.               DrawLen = DrawRightX - DrawLeftX + 1;
  1446.               DivResult = _DivTable[DrawLen];
  1447.               TempLen = 0;
  1448.               if (DrawLeftX<VMinX)
  1449.                 {
  1450.                   TempLen = VMinX - DrawLeftX;
  1451.                   DrawLeftX = VMinX;
  1452.                 } // End if
  1453.               if (DrawRightX>VMaxX)
  1454.                 {
  1455.                   DrawRightX = VMaxX;
  1456.                 } // End if
  1457.  
  1458.               //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1459.               if (DrawLen>0)
  1460.                 {
  1461.                   InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  1462.                   InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1463.                 } // End if
  1464.               DrawLeftI += InDeltaDI*TempLen;
  1465.               DrawLeftH += InDeltaDh*TempLen;
  1466.               DrawBuffer = _DestBuffer + DrawLeftX;
  1467.               DrawLen = DrawRightX - DrawLeftX + 1;
  1468.               for (j=0;j<DrawLen;j++)
  1469.                 {
  1470.                   ShadeOffset = (DrawLeftI>>8)&0xFF00;
  1471.                   HazeOffset = ((DrawLeftH>>8)&0xFF00) + _ShadeBuffer[ShadeOffset+nColor];
  1472.                   *DrawBuffer = _HazeBuffer[HazeOffset];
  1473.                   DrawBuffer++;
  1474.                   DrawLeftI += InDeltaDI;
  1475.                   DrawLeftH += InDeltaDh;
  1476.                 } // End for
  1477.             } // End if
  1478.  
  1479.           _DestBuffer += _AddDest;
  1480.           _LeftX += _LeftDx;
  1481.           _RightX += _RightDx;
  1482.           _LeftI += _LeftDI;
  1483.           _RightI += _RightDI;
  1484.           _LeftH += _LeftDh;
  1485.           _RightH += _RightDh;
  1486.         } // End for
  1487.     } // End else        
  1488. } // End of _DrawSolidGrdHazeHorz
  1489.                              
  1490.  
  1491. // VOID _DrawTextureNoHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  1492. //
  1493. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  1494.  
  1495. VOID _DrawTextureNoHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  1496.                               LONG SideClipped )
  1497. {
  1498.   if (SkipRow!=0)
  1499.     {
  1500.       _LeftX += _LeftDx*SkipRow;
  1501.       _RightX += _RightDx*SkipRow;
  1502.       _LeftU += _LeftDu*SkipRow;
  1503.       _RightU += _RightDu*SkipRow;
  1504.       _LeftV += _LeftDv*SkipRow;
  1505.       _RightV += _RightDv*SkipRow;
  1506.       _LeftH += _LeftDh*SkipRow;
  1507.       _RightH += _RightDh*SkipRow;
  1508.       _DestBuffer += _AddDest*SkipRow;
  1509.     } // End if
  1510.  
  1511.   nColor &= 0xFF;
  1512.  
  1513.   LONG i,j,DrawLen;
  1514.   LONG DrawLeftX,DrawRightX;
  1515.   LONG DrawLeftU,DrawRightU;
  1516.   LONG DrawLeftV,DrawRightV;
  1517.   LONG DrawLeftH,DrawRightH;
  1518.   BYTE *DrawBuffer;
  1519.   nLoopCount -= SkipRow;
  1520.  
  1521.   float DivResult;
  1522.   LONG TexOffset;
  1523.   LONG HazeOffset;
  1524.  
  1525.   if (!SideClipped)
  1526.     {
  1527.       for (i=0;i<nLoopCount;i++)
  1528.         {
  1529.           DrawLeftX = (_LeftX>>16);
  1530.           DrawRightX = (_RightX>>16);
  1531.           DrawLeftU = _LeftU;
  1532.           DrawRightU = _RightU;
  1533.           DrawLeftV = _LeftV;
  1534.           DrawRightV = _RightV;
  1535.           DrawLeftH = _LeftH;
  1536.           DrawRightH = _RightH;
  1537.  
  1538.           DrawBuffer = _DestBuffer + DrawLeftX;
  1539.           DrawLen = DrawRightX - DrawLeftX + 1;
  1540.           DivResult = _DivTable[DrawLen];
  1541.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1542.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1543.           if (DrawLen>0)
  1544.             {
  1545.               InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1546.             } // End if
  1547.  
  1548.           for (j=0;j<DrawLen;j++)
  1549.             {
  1550.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1551.               HazeOffset = ((DrawLeftH>>8)&0xFF00) + _TextureBuffer[TexOffset];
  1552.               *DrawBuffer = _HazeBuffer[HazeOffset];
  1553.               DrawBuffer++;
  1554.               DrawLeftU += InDeltaDu;
  1555.               DrawLeftV += InDeltaDv;
  1556.               DrawLeftH += InDeltaDh;
  1557.             } // End for
  1558.           _DestBuffer += _AddDest;
  1559.           _LeftX += _LeftDx;
  1560.           _RightX += _RightDx;
  1561.           _LeftU += _LeftDu;
  1562.           _RightU += _RightDu;
  1563.           _LeftV += _LeftDv;
  1564.           _RightV += _RightDv;
  1565.           _LeftH += _LeftDh;
  1566.           _RightH += _RightDh;
  1567.         } // End for
  1568.     } // End if
  1569.   else
  1570.     {
  1571.       for (i=0;i<nLoopCount;i++)
  1572.         {
  1573.           DrawLeftX = (_LeftX>>16);
  1574.           DrawRightX = (_RightX>>16);
  1575.           DrawLeftU = _LeftU;
  1576.           DrawRightU = _RightU;
  1577.           DrawLeftV = _LeftV;
  1578.           DrawRightV = _RightV;
  1579.           DrawLeftH = _LeftH;
  1580.           DrawRightH = _RightH;
  1581.  
  1582.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  1583.             {
  1584.               DrawLen = TempLen = DrawRightX - DrawLeftX + 1;
  1585.               DivResult = _DivTable[TempLen];
  1586.               TempLen = 0;
  1587.               if (DrawLeftX<VMinX)
  1588.                 {
  1589.                   TempLen = VMinX - DrawLeftX;
  1590.                   DrawLeftX = VMinX;
  1591.                 } // End if
  1592.               if (DrawRightX>VMaxX)
  1593.                 {
  1594.                   DrawRightX = VMaxX;
  1595.                 } // End if
  1596.  
  1597.               if (DrawLen>0)
  1598.                 {
  1599.                   InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1600.                 } // End if
  1601.                 
  1602.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1603.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1604.  
  1605.               DrawLeftU += InDeltaDu*TempLen;
  1606.               DrawLeftV += InDeltaDv*TempLen;
  1607.               DrawLeftH += InDeltaDh*TempLen;
  1608.  
  1609.               DrawBuffer = _DestBuffer + DrawLeftX;
  1610.               DrawLen = DrawRightX - DrawLeftX + 1;
  1611.                 
  1612.               for (j=0;j<DrawLen;j++)
  1613.                 {
  1614.                   TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1615.                   HazeOffset = ((DrawLeftH>>8)&0xFF00) + _TextureBuffer[TexOffset];
  1616.                   *DrawBuffer = _HazeBuffer[HazeOffset];
  1617.                   DrawBuffer++;
  1618.                   DrawLeftU += InDeltaDu;
  1619.                   DrawLeftV += InDeltaDv;
  1620.                   DrawLeftH += InDeltaDh;
  1621.                 } // End for
  1622.             } // End if
  1623.  
  1624.           _DestBuffer += _AddDest;
  1625.           _LeftX += _LeftDx;
  1626.           _RightX += _RightDx;
  1627.           _LeftU += _LeftDu;
  1628.           _RightU += _RightDu;
  1629.           _LeftV += _LeftDv;
  1630.           _RightV += _RightDv;
  1631.           _LeftH += _LeftDh;
  1632.           _RightH += _RightDh;
  1633.         } // End for
  1634.     } // End else
  1635. } // End of _DrawTextureNoHazeHorz
  1636.                              
  1637.  
  1638. // VOID _DrawTextureFlatHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  1639. //
  1640. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  1641.  
  1642. VOID _DrawTextureFlatHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  1643.                                 LONG SideClipped )
  1644. {
  1645.   if (SkipRow!=0)
  1646.     {
  1647.       _LeftX += _LeftDx*SkipRow;
  1648.       _RightX += _RightDx*SkipRow;
  1649.       _LeftU += _LeftDu*SkipRow;
  1650.       _RightU += _RightDu*SkipRow;
  1651.       _LeftV += _LeftDv*SkipRow;
  1652.       _RightV += _RightDv*SkipRow;
  1653.       _LeftH += _LeftDh*SkipRow;
  1654.       _RightH += _RightDh*SkipRow;
  1655.       _DestBuffer += _AddDest*SkipRow;
  1656.     } // End if
  1657.  
  1658.   nColor &= 0xFF;
  1659.  
  1660.   LONG i,j,DrawLen;
  1661.   LONG DrawLeftX,DrawRightX;
  1662.   LONG DrawLeftU,DrawRightU;
  1663.   LONG DrawLeftV,DrawRightV;
  1664.   LONG DrawLeftH,DrawRightH;
  1665.   BYTE *DrawBuffer;
  1666.   nLoopCount -= SkipRow;
  1667.  
  1668.   float DivResult;
  1669.   LONG TexOffset;
  1670.   LONG HazeOffset;
  1671.   LONG ShadeLevel;
  1672.   BYTE TexColor;
  1673.  
  1674.   ShadeLevel = _LeftI>>8;  
  1675.  
  1676.   if (!SideClipped)
  1677.     {
  1678.       for (i=0;i<nLoopCount;i++)
  1679.         {
  1680.           DrawLeftX = (_LeftX>>16);
  1681.           DrawRightX = (_RightX>>16);
  1682.           DrawLeftU = _LeftU;
  1683.           DrawRightU = _RightU;
  1684.           DrawLeftV = _LeftV;
  1685.           DrawRightV = _RightV;
  1686.           DrawLeftH = _LeftH;
  1687.           DrawRightH = _RightH;
  1688.  
  1689.           DrawBuffer = _DestBuffer + DrawLeftX;
  1690.           DrawLen = DrawRightX - DrawLeftX + 1;
  1691.           DivResult = _DivTable[DrawLen];
  1692.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1693.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1694.  
  1695.           if (DrawLen>0)
  1696.             {
  1697.               InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1698.             } // End if
  1699.             
  1700.           for (j=0;j<DrawLen;j++)
  1701.             {
  1702.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1703.               TexColor = _TextureBuffer[TexOffset];
  1704.               HazeOffset = ((DrawLeftH>>8)&0xFF00) + _ShadeBuffer[ShadeLevel+TexColor];
  1705.               *DrawBuffer = _HazeBuffer[HazeOffset];
  1706.               DrawBuffer++;
  1707.               DrawLeftU += InDeltaDu;
  1708.               DrawLeftV += InDeltaDv;
  1709.               DrawLeftH += InDeltaDh;
  1710.             } // End for
  1711.           _DestBuffer += _AddDest;
  1712.           _LeftX += _LeftDx;
  1713.           _RightX += _RightDx;
  1714.           _LeftU += _LeftDu;
  1715.           _RightU += _RightDu;
  1716.           _LeftV += _LeftDv;
  1717.           _RightV += _RightDv;
  1718.           _LeftH += _LeftDh;
  1719.           _RightH += _RightDh;
  1720.         } // End for
  1721.     } // End if
  1722.   else
  1723.     {
  1724.       for (i=0;i<nLoopCount;i++)
  1725.         {
  1726.           DrawLeftX = (_LeftX>>16);
  1727.           DrawRightX = (_RightX>>16);
  1728.           DrawLeftU = _LeftU;
  1729.           DrawRightU = _RightU;
  1730.           DrawLeftV = _LeftV;
  1731.           DrawRightV = _RightV;
  1732.           DrawLeftH = _LeftH;
  1733.           DrawRightH = _RightH;
  1734.  
  1735.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  1736.             {
  1737.               DrawLen = TempLen = DrawRightX - DrawLeftX + 1;
  1738.               DivResult = _DivTable[TempLen];
  1739.               TempLen = 0;
  1740.               if (DrawLeftX<VMinX)
  1741.                 {
  1742.                   TempLen = VMinX - DrawLeftX;
  1743.                   DrawLeftX = VMinX;
  1744.                 } // End if
  1745.               if (DrawRightX>VMaxX)
  1746.                 {
  1747.                   DrawRightX = VMaxX;
  1748.                 } // End if
  1749.  
  1750.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1751.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1752.  
  1753.               if (DrawLen>0)
  1754.                 {
  1755.                   InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1756.                 } // End if
  1757.             
  1758.               DrawLeftU += InDeltaDu*TempLen;
  1759.               DrawLeftV += InDeltaDv*TempLen;
  1760.               DrawLeftH += InDeltaDh*TempLen;
  1761.  
  1762.               DrawBuffer = _DestBuffer + DrawLeftX;
  1763.               DrawLen = DrawRightX - DrawLeftX + 1;
  1764.               for (j=0;j<DrawLen;j++)
  1765.                 {
  1766.                   TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1767.                   TexColor = _TextureBuffer[TexOffset];
  1768.                   HazeOffset = ((DrawLeftH>>8)&0xFF00) + _ShadeBuffer[ShadeLevel+TexColor];
  1769.                   *DrawBuffer = _HazeBuffer[HazeOffset];
  1770.                   DrawBuffer++;
  1771.                   DrawLeftU += InDeltaDu;
  1772.                   DrawLeftV += InDeltaDv;
  1773.                   DrawLeftH += InDeltaDh;
  1774.                 } // End for
  1775.             } // End if
  1776.  
  1777.           _DestBuffer += _AddDest;
  1778.           _LeftX += _LeftDx;
  1779.           _RightX += _RightDx;
  1780.           _LeftU += _LeftDu;
  1781.           _RightU += _RightDu;
  1782.           _LeftV += _LeftDv;
  1783.           _RightV += _RightDv;
  1784.           _LeftH += _LeftDh;
  1785.           _RightH += _RightDh;
  1786.         } // End for
  1787.     } // End else
  1788. } // End of _DrawTextureFlatHazeHorz
  1789.                              
  1790.  
  1791. // VOID _DrawTextureGrdHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow, LONG SideClipped )
  1792. //
  1793. // EAX = Color, EDX = LoopCount, EBX = SkipRow, ECX = SideClipped
  1794.  
  1795. VOID _DrawTextureGrdHazeHorz ( LONG nColor, LONG nLoopCount, LONG SkipRow,
  1796.                                LONG SideClipped )
  1797. {
  1798.   if (SkipRow!=0)
  1799.     {
  1800.       _LeftX += _LeftDx*SkipRow;
  1801.       _RightX += _RightDx*SkipRow;
  1802.       _LeftU += _LeftDu*SkipRow;
  1803.       _RightU += _RightDu*SkipRow;
  1804.       _LeftV += _LeftDv*SkipRow;
  1805.       _RightV += _RightDv*SkipRow;
  1806.       _LeftI += _LeftDI*SkipRow;
  1807.       _RightI += _RightDI*SkipRow;
  1808.       _LeftH += _LeftDh*SkipRow;
  1809.       _RightH += _RightDh*SkipRow;
  1810.       _DestBuffer += _AddDest*SkipRow;
  1811.     } // End if
  1812.  
  1813.   nColor &= 0xFF;
  1814.  
  1815.   LONG i,j,DrawLen;
  1816.   LONG DrawLeftX,DrawRightX;
  1817.   LONG DrawLeftU,DrawRightU;
  1818.   LONG DrawLeftV,DrawRightV;
  1819.   LONG DrawLeftI,DrawRightI;
  1820.   LONG DrawLeftH,DrawRightH;
  1821.   BYTE *DrawBuffer;
  1822.   nLoopCount -= SkipRow;
  1823.  
  1824.   float DivResult;
  1825.   LONG TexOffset;
  1826.   LONG ShadeLevel;
  1827.   LONG HazeOffset;
  1828.   BYTE TexColor;
  1829.  
  1830.   ShadeLevel = _LeftI>>8;  
  1831.  
  1832.   if (!SideClipped)
  1833.     {
  1834.       for (i=0;i<nLoopCount;i++)
  1835.         {
  1836.           DrawLeftX = (_LeftX>>16);
  1837.           DrawRightX = (_RightX>>16);
  1838.           DrawLeftU = _LeftU;
  1839.           DrawRightU = _RightU;
  1840.           DrawLeftV = _LeftV;
  1841.           DrawRightV = _RightV;
  1842.           DrawLeftI = _LeftI;
  1843.           DrawRightI = _RightI;
  1844.           DrawLeftH = _LeftH;
  1845.           DrawRightH = _RightH;
  1846.  
  1847.           DrawBuffer = _DestBuffer + DrawLeftX;
  1848.           DrawLen = DrawRightX - DrawLeftX + 1;
  1849.           DivResult = _DivTable[DrawLen];
  1850.           InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1851.           InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1852.           //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1853.           if (DrawLen>0)
  1854.             {
  1855.               InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  1856.               InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1857.             } // End if  
  1858.  
  1859.           for (j=0;j<DrawLen;j++)
  1860.             {
  1861.               TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1862.               TexColor = _TextureBuffer[TexOffset];
  1863.               ShadeLevel = (DrawLeftI>>8)&0xFF00;
  1864.               HazeOffset = ((DrawLeftH>>8)&0xFF00) + _ShadeBuffer[ShadeLevel+TexColor];
  1865.               *DrawBuffer = _HazeBuffer[HazeOffset];
  1866.               DrawBuffer++;
  1867.               DrawLeftU += InDeltaDu;
  1868.               DrawLeftV += InDeltaDv;
  1869.               DrawLeftI += InDeltaDI;
  1870.               DrawLeftH += InDeltaDh;
  1871.             } // End for
  1872.           _DestBuffer += _AddDest;
  1873.           _LeftX += _LeftDx;
  1874.           _RightX += _RightDx;
  1875.           _LeftU += _LeftDu;
  1876.           _RightU += _RightDu;
  1877.           _LeftV += _LeftDv;
  1878.           _RightV += _RightDv;
  1879.           _LeftI += _LeftDI;
  1880.           _RightI += _RightDI;
  1881.           _LeftH += _LeftDh;
  1882.           _RightH += _RightDh;
  1883.         } // End for
  1884.     } // End if
  1885.   else
  1886.     {
  1887.       for (i=0;i<nLoopCount;i++)
  1888.         {
  1889.           DrawLeftX = (_LeftX>>16);
  1890.           DrawRightX = (_RightX>>16);
  1891.           DrawLeftU = _LeftU;
  1892.           DrawRightU = _RightU;
  1893.           DrawLeftV = _LeftV;
  1894.           DrawRightV = _RightV;
  1895.           DrawLeftI = _LeftI;
  1896.           DrawRightI = _RightI;
  1897.           DrawLeftH = _LeftH;
  1898.           DrawRightH = _RightH;
  1899.  
  1900.           if ((DrawLeftX<=VMaxX)&&(DrawRightX>=VMinX))
  1901.             {
  1902.               DrawLen = DrawRightX - DrawLeftX + 1;
  1903.               DivResult = _DivTable[DrawLen];
  1904.               TempLen = 0;
  1905.               if (DrawLeftX<VMinX)
  1906.                 {
  1907.                   TempLen = VMinX - DrawLeftX;
  1908.                   DrawLeftX = VMinX;
  1909.                 } // End if
  1910.               if (DrawRightX>VMaxX)
  1911.                 {
  1912.                   DrawRightX = VMaxX;
  1913.                 } // End if
  1914.  
  1915.               InDeltaDu = DivResult*(DrawRightU-DrawLeftU);
  1916.               InDeltaDv = DivResult*(DrawRightV-DrawLeftV);
  1917.               //InDeltaDI = DivResult*(DrawRightI-DrawLeftI);
  1918.               if (DrawLen>0)
  1919.                 {
  1920.                   InDeltaDI = (DrawRightI-DrawLeftI) / DrawLen;
  1921.                   InDeltaDh = (DrawRightH-DrawLeftH) / DrawLen;
  1922.                 } // End if  
  1923.  
  1924.                DrawLeftU += InDeltaDu*TempLen;
  1925.                DrawLeftV += InDeltaDv*TempLen;
  1926.                DrawLeftI += InDeltaDI*TempLen;
  1927.                DrawLeftH += InDeltaDh*TempLen;
  1928.  
  1929.                DrawBuffer = _DestBuffer + DrawLeftX;
  1930.                DrawLen = DrawRightX - DrawLeftX + 1;
  1931.                for (j=0;j<DrawLen;j++)
  1932.                  {
  1933.                    TexOffset = ((DrawLeftV>>8)&0xFF00) + (DrawLeftU>>16);
  1934.                    TexColor = _TextureBuffer[TexOffset];
  1935.                    ShadeLevel = (DrawLeftI>>8)&0xFF00;
  1936.                    HazeOffset = ((DrawLeftH>>8)&0xFF00) + _ShadeBuffer[ShadeLevel+TexColor];
  1937.                    *DrawBuffer = _HazeBuffer[HazeOffset];
  1938.                    DrawBuffer++;
  1939.                    DrawLeftU += InDeltaDu;
  1940.                    DrawLeftV += InDeltaDv;
  1941.                    DrawLeftI += InDeltaDI;
  1942.                    DrawLeftH += InDeltaDh;
  1943.                  } // End for
  1944.              } // End if
  1945.  
  1946.            _DestBuffer += _AddDest;
  1947.            _LeftX += _LeftDx;
  1948.            _RightX += _RightDx;
  1949.            _LeftU += _LeftDu;
  1950.            _RightU += _RightDu;
  1951.            _LeftV += _LeftDv;
  1952.            _RightV += _RightDv;
  1953.            _LeftI += _LeftDI;
  1954.            _RightI += _RightDI;
  1955.            _LeftH += _LeftDh;
  1956.            _RightH += _RightDh;
  1957.          } // End for
  1958.      } // End else
  1959. } // End of _DrawTextureGrdHazeHorz
  1960.                              
  1961.  
  1962.